home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 1.0 beta / flock-1.0RC3.en-US.win32.exe / flock / components / WebContentConverter.js < prev    next >
Text File  |  2007-10-18  |  24KB  |  764 lines
  1. //@line 38 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/WebContentConverter.js"
  2.  
  3. const Cc = Components.classes;
  4. const Ci = Components.interfaces;
  5. const Cr = Components.results;
  6.  
  7. function LOG(str) {
  8.   dump("*** " + str + "\n");
  9. }
  10.  
  11. const WCCR_CONTRACTID = "@mozilla.org/embeddor.implemented/web-content-handler-registrar;1";
  12. const WCCR_CLASSID = Components.ID("{792a7e82-06a0-437c-af63-b2d12e808acc}");
  13. const WCCR_CLASSNAME = "Web Content Handler Registrar";
  14.  
  15. const WCC_CLASSID = Components.ID("{db7ebf28-cc40-415f-8a51-1b111851df1e}");
  16. const WCC_CLASSNAME = "Web Service Handler";
  17.  
  18. const TYPE_MAYBE_FEED = "application/vnd.mozilla.maybe.feed";
  19. const TYPE_ANY = "*/*";
  20.  
  21. const PREF_CONTENTHANDLERS_AUTO = "browser.contentHandlers.auto.";
  22. const PREF_CONTENTHANDLERS_BRANCH = "browser.contentHandlers.types.";
  23. const PREF_SELECTED_WEB = "browser.feeds.handlers.webservice";
  24. const PREF_SELECTED_ACTION = "browser.feeds.handler";
  25. const PREF_SELECTED_READER = "browser.feeds.handler.default";
  26.  
  27. const NS_ERROR_MODULE_DOM = 2152923136;
  28. const NS_ERROR_DOM_SYNTAX_ERR = NS_ERROR_MODULE_DOM + 12;
  29.  
  30. function WebContentConverter() {
  31. }
  32. WebContentConverter.prototype = {
  33.   convert: function WCC_convert() { },
  34.   asyncConvertData: function WCC_asyncConvertData() { },
  35.   onDataAvailable: function WCC_onDataAvailable() { },
  36.   onStopRequest: function WCC_onStopRequest() { },
  37.   
  38.   onStartRequest: function WCC_onStartRequest(request, context) {
  39.     var wccr = 
  40.         Cc[WCCR_CONTRACTID].
  41.         getService(Ci.nsIWebContentConverterService);
  42.     wccr.loadPreferredHandler(request);
  43.   },
  44.   
  45.   QueryInterface: function WCC_QueryInterface(iid) {
  46.     if (iid.equals(Ci.nsIStreamConverter) ||
  47.         iid.equals(Ci.nsIStreamListener) ||
  48.         iid.equals(Ci.nsISupports))
  49.       return this;
  50.     throw Cr.NS_ERROR_NO_INTERFACE;
  51.   }
  52. };
  53.  
  54. var WebContentConverterFactory = {
  55.   createInstance: function WCCF_createInstance(outer, iid) {
  56.     if (outer != null)
  57.       throw Cr.NS_ERROR_NO_AGGREGATION;
  58.     return new WebContentConverter().QueryInterface(iid);
  59.   },
  60.     
  61.   QueryInterface: function WCC_QueryInterface(iid) {
  62.     if (iid.equals(Ci.nsIFactory) ||
  63.         iid.equals(Ci.nsISupports))
  64.       return this;
  65.     throw Cr.NS_ERROR_NO_INTERFACE;
  66.   }
  67. };
  68.  
  69. function ServiceInfo(contentType, uri, name) {
  70.   this._contentType = contentType;
  71.   this._uri = uri;
  72.   this._name = name;
  73. }
  74. ServiceInfo.prototype = {
  75.   /**
  76.    * See nsIWebContentHandlerInfo
  77.    */
  78.   get contentType() {
  79.     return this._contentType;
  80.   },
  81.  
  82.   /**
  83.    * See nsIWebContentHandlerInfo
  84.    */
  85.   get uri() {
  86.     return this._uri;
  87.   },
  88.  
  89.   /**
  90.    * See nsIWebContentHandlerInfo
  91.    */
  92.   get name() {
  93.     return this._name;
  94.   },
  95.   
  96.   /**
  97.    * See nsIWebContentHandlerInfo
  98.    */
  99.   getHandlerURI: function SI_getHandlerURI(uri) {
  100.     return this._uri.replace(/%s/gi, encodeURIComponent(uri));
  101.   },
  102.   
  103.   /**
  104.    * See nsIWebContentHandlerInfo
  105.    */
  106.   equals: function SI_equals(other) {
  107.     return this.contentType == other.contentType &&
  108.            this.uri == other.uri;
  109.   },
  110.   
  111.   QueryInterface: function SI_QueryInterface(iid) {
  112.     if (iid.equals(Ci.nsIWebContentHandlerInfo) ||
  113.         iid.equals(Ci.nsISupports))
  114.       return this;
  115.     throw Cr.NS_ERROR_NO_INTERFACE;
  116.   }
  117. };
  118.  
  119. var WebContentConverterRegistrar = {
  120.   _contentTypes: { },
  121.   _protocols: { },
  122.   
  123.   /**
  124.    * Track auto handlers for various content types using a content-type to 
  125.    * handler map.
  126.    */
  127.   _autoHandleContentTypes: { },
  128.  
  129.   /**
  130.    * See nsIWebContentConverterService
  131.    */
  132.   getAutoHandler: 
  133.   function WCCR_getAutoHandler(contentType) {
  134.     contentType = this._resolveContentType(contentType);
  135.     if (contentType in this._autoHandleContentTypes)
  136.       return this._autoHandleContentTypes[contentType];
  137.     return null;
  138.   },
  139.   
  140.   /**
  141.    * See nsIWebContentConverterService
  142.    */
  143.   setAutoHandler:
  144.   function WCCR_setAutoHandler(contentType, handler) {
  145.     if (handler && !this._typeIsRegistered(contentType, handler.uri))
  146.       throw Cr.NS_ERROR_NOT_AVAILABLE;
  147.       
  148.     contentType = this._resolveContentType(contentType);
  149.     this._setAutoHandler(contentType, handler);
  150.     
  151.     var ps = 
  152.         Cc["@mozilla.org/preferences-service;1"].
  153.         getService(Ci.nsIPrefService);
  154.     var autoBranch = ps.getBranch(PREF_CONTENTHANDLERS_AUTO);
  155.     if (handler)
  156.       autoBranch.setCharPref(contentType, handler.uri);
  157.     else if (autoBranch.prefHasUserValue(contentType))
  158.       autoBranch.clearUserPref(contentType);
  159.      
  160.     ps.savePrefFile(null);
  161.   },
  162.   
  163.   /**
  164.    * Update the internal data structure (not persistent)
  165.    */
  166.   _setAutoHandler:
  167.   function WCCR__setAutoHandler(contentType, handler) {
  168.     if (handler) 
  169.       this._autoHandleContentTypes[contentType] = handler;
  170.     else if (contentType in this._autoHandleContentTypes)
  171.       delete this._autoHandleContentTypes[contentType];
  172.   },
  173.   
  174.   /**
  175.    * See nsIWebContentConverterService
  176.    */
  177.   getWebContentHandlerByURI:
  178.   function WCCR_getWebContentHandlerByURI(contentType, uri) {
  179.     var handlers = this.getContentHandlers(contentType, { });
  180.     for (var i = 0; i < handlers.length; ++i) {
  181.       if (handlers[i].uri == uri) 
  182.         return handlers[i];
  183.     }
  184.     return null;
  185.   },
  186.   
  187.   /**
  188.    * See nsIWebContentConverterService
  189.    */
  190.   loadPreferredHandler: 
  191.   function WCCR_loadPreferredHandler(request) {
  192.     var channel = request.QueryInterface(Ci.nsIChannel);
  193.     var contentType = this._resolveContentType(channel.contentType);
  194.     var handler = this.getAutoHandler(contentType);
  195.     if (handler) {
  196.       request.cancel(Cr.NS_ERROR_FAILURE);
  197.       
  198.       var webNavigation = 
  199.           channel.notificationCallbacks.getInterface(Ci.nsIWebNavigation);
  200.       webNavigation.loadURI(handler.getHandlerURI(channel.URI.spec), 
  201.                             Ci.nsIWebNavigation.LOAD_FLAGS_NONE, 
  202.                             null, null, null);
  203.     }      
  204.   },
  205.   
  206.   /**
  207.    * See nsIWebContentConverterService
  208.    */
  209.   removeProtocolHandler: 
  210.   function WCCR_removeProtocolHandler(protocol, uri) {
  211.     function notURI(currentURI) {
  212.       return currentURI != uri;
  213.     }
  214.   
  215.     if (protocol in this._protocols) 
  216.       this._protocols[protocol] = this._protocols[protocol].filter(notURI);
  217.   },
  218.   
  219.   /**
  220.    * See nsIWebContentConverterService
  221.    */
  222.   removeContentHandler: 
  223.   function WCCR_removeContentHandler(contentType, uri) {
  224.     function notURI(serviceInfo) {
  225.       return serviceInfo.uri != uri;
  226.     }
  227.   
  228.     if (contentType in this._contentTypes) {
  229.       this._contentTypes[contentType] = 
  230.         this._contentTypes[contentType].filter(notURI);
  231.     }
  232.   },
  233.   
  234.   /**
  235.    *
  236.    */
  237.   _mappings: { 
  238.     "application/rss+xml": TYPE_MAYBE_FEED,
  239.     "application/atom+xml": TYPE_MAYBE_FEED,
  240.   },
  241.   
  242.   /**
  243.    * These are types for which there is a separate content converter aside 
  244.    * from our built in generic one. We should not automatically register
  245.    * a factory for creating a converter for these types.
  246.    */
  247.   _blockedTypes: {
  248.     "application/vnd.mozilla.maybe.feed": true,
  249.   },
  250.   
  251.   /**
  252.    * Determines the "internal" content type based on the _mappings.
  253.    * @param   contentType
  254.    * @returns The resolved contentType value. 
  255.    */
  256.   _resolveContentType: 
  257.   function WCCR__resolveContentType(contentType) {
  258.     if (contentType in this._mappings)
  259.       return this._mappings[contentType];
  260.     return contentType;
  261.   },
  262.  
  263.   _wrapString: function WCCR__wrapString(string) {
  264.     var supportsString = 
  265.         Cc["@mozilla.org/supports-string;1"].
  266.         createInstance(Ci.nsISupportsString);
  267.     supportsString.data = string;
  268.     return supportsString;
  269.   },
  270.  
  271.   _makeURI: function(aURL, aOriginCharset, aBaseURI) {
  272.     var ioService = Components.classes["@mozilla.org/network/io-service;1"]
  273.                               .getService(Components.interfaces.nsIIOService);
  274.     return ioService.newURI(aURL, aOriginCharset, aBaseURI);
  275.   },
  276.  
  277.   _confirmAddHandler: function WCCR__confirmAddHandler(contentType, title, uri, contentWindow) {
  278.     var args =
  279.         Cc["@mozilla.org/supports-array;1"].
  280.         createInstance(Ci.nsISupportsArray);
  281.     
  282.     var paramBlock = 
  283.         Cc["@mozilla.org/embedcomp/dialogparam;1"].
  284.         createInstance(Ci.nsIDialogParamBlock);
  285.     // Used to tell the WCCR that the user chose to add the handler (rather 
  286.     // than canceling).
  287.     const PARAM_SHOULD_ADD_HANDLER = 0;
  288.     paramBlock.SetInt(PARAM_SHOULD_ADD_HANDLER, 0);
  289.     args.AppendElement(paramBlock);
  290.  
  291.     args.AppendElement(uri);
  292.     args.AppendElement(this._wrapString(title));
  293.     args.AppendElement(this._wrapString(contentType));
  294.  
  295.     var typeType = 
  296.         Cc["@mozilla.org/supports-PRInt32;1"].
  297.         createInstance(Ci.nsISupportsPRInt32);
  298.     typeType.data = 1;
  299.     args.AppendElement(typeType);
  300.  
  301.     var browserContentWindow = contentWindow.top;
  302.     var browserWindow =
  303.         browserContentWindow.QueryInterface(Ci.nsIInterfaceRequestor)
  304.                             .getInterface(Ci.nsIWebNavigation)
  305.                             .QueryInterface(Ci.nsIDocShellTreeItem)
  306.                             .rootTreeItem
  307.                             .QueryInterface(Ci.nsIInterfaceRequestor)
  308.                             .getInterface(Ci.nsIDOMWindow);
  309.  
  310.     // The tabbrowser implementation selects the associated tab when this
  311.     // is event is dispatched on the windoow.
  312.     var event = browserWindow.document.createEvent("Events");
  313.     event.initEvent("DOMWillOpenModalDialog", true, true);
  314.     browserContentWindow.dispatchEvent(event);
  315.  
  316.     var ww = Cc["@mozilla.org/embedcomp/window-watcher;1"].
  317.              getService(Ci.nsIWindowWatcher);
  318.     ww.openWindow(browserWindow,
  319.                   "chrome://browser/content/feeds/addFeedReader.xul",
  320.                   "", "modal,titlebar,centerscreen,dialog=yes", args);
  321.  
  322.     var event = browserWindow.document.createEvent("Events");
  323.     event.initEvent("DOMModalDialogClosed", true, true);
  324.     browserContentWindow.dispatchEvent(event);
  325.  
  326.     return paramBlock.GetInt(PARAM_SHOULD_ADD_HANDLER);
  327.   },
  328.  
  329.   _checkForDuplicateContentType: 
  330.   function WCCR__checkForDuplicateContentType(contentType, uri, title, contentWindow) {
  331.     contentType = this._resolveContentType(contentType);
  332.     if (this._typeIsRegistered(contentType, uri.spec)) {
  333.       // Show a special dialog for the feed case (XXXben - generalize at some 
  334.       // point to allow other types to register specialized prompts).
  335.       this._confirmAddHandler(contentType, title, uri, contentWindow);
  336.       return false;
  337.     }
  338.     return true;
  339.   },
  340.  
  341.   /**
  342.    * See nsIWebContentHandlerRegistrar
  343.    */
  344.   registerProtocolHandler: 
  345.   function WCCR_registerProtocolHandler(protocol, uriString, title, contentWindow) {
  346. //@line 393 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/WebContentConverter.js"
  347.   },
  348.  
  349.   /**
  350.    * See nsIWebContentHandlerRegistrar
  351.    * This is the web front end into the registration system, so a prompt to 
  352.    * confirm the registration is provided, and the result is saved to 
  353.    * preferences.
  354.    */
  355.   registerContentHandler: 
  356.   function WCCR_registerContentHandler(contentType, uriString, title, contentWindow) {
  357.     LOG("registerContentHandler(" + contentType + "," + uri + "," + title + ")");
  358.  
  359.     try {
  360.       var uri = this._makeURI(uriString);
  361.     } catch (ex) {
  362.       // not supposed to throw according to spec
  363.       return; 
  364.     }
  365.  
  366.     // If the uri doesn't contain '%s', it won't be a good content handler
  367.     if (uri.spec.indexOf("%s") < 0)
  368.       throw NS_ERROR_DOM_SYNTAX_ERR;
  369.  
  370.     // For security reasons we reject non-http(s) urls (see bug Bug 354316),
  371.     // we may need to revise this once we support more content types
  372.     if (uri.scheme != "http" &&  uri.scheme != "https")
  373.       throw("Permission denied to add " + uri.spec + "as a content handler");
  374.  
  375.     // XXXben - for Firefox 2 we only support feed types
  376.     // XXX this should be a "security exception" according to spec, but that
  377.     // isn't defined yet.
  378.     contentType = this._resolveContentType(contentType);
  379.     if (contentType != TYPE_MAYBE_FEED)
  380.       return;    
  381.  
  382.     if (!this._checkForDuplicateContentType(contentType, uri, title, contentWindow) ||
  383.         !this._confirmAddHandler(contentType, title, uri, contentWindow))
  384.       return;
  385.  
  386.     var spec = uri.spec;
  387.     this._registerContentHandler(contentType, spec, title);
  388.     this._saveContentHandlerToPrefs(contentType, spec, title);    
  389.   },
  390.  
  391.   /**
  392.    * Save Web Content Handler metadata to persistent preferences. 
  393.    * @param   contentType
  394.    *          The content Type being handled
  395.    * @param   uri
  396.    *          The uri of the web service
  397.    * @param   title
  398.    *          The human readable name of the web service
  399.    *
  400.    * This data is stored under:
  401.    * 
  402.    *    browser.contentHandlers.type0 = content/type
  403.    *    browser.contentHandlers.uri0 = http://www.foo.com/q=%s
  404.    *    browser.contentHandlers.title0 = Foo 2.0alphr
  405.    */
  406.   _saveContentHandlerToPrefs: 
  407.   function WCCR__saveContentHandlerToPrefs(contentType, uri, title) {
  408.     var ps = 
  409.         Cc["@mozilla.org/preferences-service;1"].
  410.         getService(Ci.nsIPrefService);
  411.     var i = 0;
  412.     var typeBranch = null;
  413.     while (true) {
  414.       typeBranch = 
  415.         ps.getBranch(PREF_CONTENTHANDLERS_BRANCH + i + ".");
  416.       try {
  417.         typeBranch.getCharPref("type");
  418.         ++i;
  419.       }
  420.       catch (e) {
  421.         // No more handlers
  422.         break;
  423.       }
  424.     }
  425.     if (typeBranch) {
  426.       typeBranch.setCharPref("type", contentType);
  427.       var pls = 
  428.           Cc["@mozilla.org/pref-localizedstring;1"].
  429.           createInstance(Ci.nsIPrefLocalizedString);
  430.       pls.data = uri;
  431.       typeBranch.setComplexValue("uri", Ci.nsIPrefLocalizedString, pls);
  432.       pls.data = title;
  433.       typeBranch.setComplexValue("title", Ci.nsIPrefLocalizedString, pls);
  434.  
  435.       ps.savePrefFile(null);
  436.     }
  437.  
  438.     // Make the new handler the last-selected handler for the preview page
  439.     // and make sure the preview page is shown the next time a feed is visited
  440.     var pb = ps.getBranch(null);
  441.     pb.setCharPref(PREF_SELECTED_READER, "web");
  442.     pb.setCharPref(PREF_SELECTED_WEB, uri);
  443.     pb.setCharPref(PREF_SELECTED_ACTION, "ask");
  444.   },
  445.  
  446.   /**
  447.    * Determines if there is a type with a particular uri registered for the 
  448.    * specified content type already.
  449.    * @param   contentType
  450.    *          The content type that the uri handles
  451.    * @param   uri
  452.    *          The uri of the 
  453.    */
  454.   _typeIsRegistered: function WCCR__typeIsRegistered(contentType, uri) {
  455.     if (!(contentType in this._contentTypes))
  456.       return false;
  457.  
  458.     var services = this._contentTypes[contentType];
  459.     for (var i = 0; i < services.length; ++i) {
  460.       // This uri has already been registered
  461.       if (services[i].uri == uri)
  462.         return true;
  463.     }
  464.     return false;
  465.   },
  466.  
  467.   /**
  468.    * Gets a stream converter contract id for the specified content type.
  469.    * @param   contentType
  470.    *          The source content type for the conversion.
  471.    * @returns A contract id to construct a converter to convert between the 
  472.    *          contentType and *\/*.
  473.    */
  474.   _getConverterContractID: function WCCR__getConverterContractID(contentType) {
  475.     const template = "@mozilla.org/streamconv;1?from=%s&to=*/*";
  476.     return template.replace(/%s/, contentType);
  477.   },
  478.  
  479.   /**
  480.    * Update the content type -> handler map. This mapping is not persisted, use
  481.    * registerContentHandler or _saveContentHandlerToPrefs for that purpose.
  482.    * @param   contentType
  483.    *          The content Type being handled
  484.    * @param   uri
  485.    *          The uri of the web service
  486.    * @param   title
  487.    *          The human readable name of the web service
  488.    */
  489.   _registerContentHandler: 
  490.   function WCCR__registerContentHandler(contentType, uri, title) {
  491.     if (!(contentType in this._contentTypes))
  492.       this._contentTypes[contentType] = [];
  493.  
  494.     // Avoid adding duplicates
  495.     if (this._typeIsRegistered(contentType, uri)) 
  496.       return;
  497.  
  498.     this._contentTypes[contentType].push(new ServiceInfo(contentType, uri, title));
  499.     
  500.     if (!(contentType in this._blockedTypes)) {
  501.       var converterContractID = this._getConverterContractID(contentType);
  502.       var cr = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
  503.       cr.registerFactory(WCC_CLASSID, WCC_CLASSNAME, converterContractID, 
  504.                          WebContentConverterFactory);
  505.     }
  506.   },
  507.  
  508.   /**
  509.    * See nsIWebContentConverterService
  510.    */
  511.   getContentHandlers: 
  512.   function WCCR_getContentHandlers(contentType, countRef) {
  513.     countRef.value = 0;
  514.     if (!(contentType in this._contentTypes))
  515.       return [];
  516.  
  517.     var handlers = this._contentTypes[contentType];
  518.     countRef.value = handlers.length;
  519.     return handlers;
  520.   },
  521.  
  522.   /**
  523.    * See nsIWebContentConverterService
  524.    */
  525.   resetHandlersForType: 
  526.   function WCCR_resetHandlersForType(contentType) {
  527.     contentType = this._resolveContentType(contentType);
  528.     var ps = 
  529.         Cc["@mozilla.org/preferences-service;1"].
  530.         getService(Ci.nsIPrefService);
  531.     try {
  532.       var i = 0;
  533.       while (true) {
  534.         var handlerBranch = 
  535.           ps.getBranch(PREF_CONTENTHANDLERS_BRANCH + i + ".");
  536.         try {
  537.           if (handlerBranch.getCharPref("type") == contentType)
  538.             handlerBranch.resetBranch("");
  539.           var defaultBranch = 
  540.               ps.getDefaultBranch(PREF_CONTENTHANDLERS_BRANCH + i + ".");
  541.           if (!this._registerContentHandlerWithBranch(defaultBranch))
  542.             break;
  543.           ++i;
  544.         }
  545.         catch (e) {
  546.         }
  547.       }
  548.     }
  549.     catch (e) {
  550.     }
  551.     ps.savePrefFile(null);
  552.   },
  553.  
  554.   /**
  555.    * Registers a handler from the settings on a branch
  556.    */
  557.   _registerContentHandlerWithBranch: function(branch) {
  558.  
  559.     /**
  560.      * Since we support up to six predefined readers, we need to handle gaps 
  561.      * better, since the first branch with user-added values will be .6
  562.      * 
  563.      * How we deal with that is to check to see if there's no prefs in the 
  564.      * branch and stop cycling once that's true.  This doesn't fix the case
  565.      * where a user manually removes a reader, but that's not supported yet!
  566.      */
  567.     
  568.     var vals = branch.getChildList("", {});
  569.     if (vals.length == 0)
  570.       return false;
  571.  
  572.     try {
  573.       var type = branch.getCharPref("type");
  574.       var uri = 
  575.           branch.getComplexValue("uri", Ci.nsIPrefLocalizedString).data;
  576.       var title = 
  577.           branch.getComplexValue("title", Ci.nsIPrefLocalizedString).data;
  578.       this._registerContentHandler(type, uri, title);
  579.     }
  580.     catch (e) {
  581.       // do nothing, the next branch might have values
  582.     }
  583.     return true;
  584.   },
  585.  
  586.   /**
  587.    * Load the auto handler, content handler and protocol tables from 
  588.    * preferences.
  589.    */
  590.   _init: function WCCR__init() {
  591.     var ps = 
  592.         Cc["@mozilla.org/preferences-service;1"].
  593.         getService(Ci.nsIPrefService);
  594.     try {
  595.       var i = 0;
  596.       while (true) {
  597.         var handlerBranch = 
  598.           ps.getBranch(PREF_CONTENTHANDLERS_BRANCH + (i++) + ".");
  599.         if (!this._registerContentHandlerWithBranch(handlerBranch))
  600.           break;
  601.       }
  602.     }
  603.     catch (e) {
  604.       // No content handlers yet, that's fine
  605.       //LOG("WCCR.init: There are no content handlers registered in preferences (benign).");
  606.     }
  607.  
  608.     // We need to do this _after_ registering all of the available handlers, 
  609.     // so that getWebContentHandlerByURI can return successfully.
  610.     try {
  611.       var autoBranch = ps.getBranch(PREF_CONTENTHANDLERS_AUTO);
  612.       var childPrefs = autoBranch.getChildList("", { });
  613.       for (var i = 0; i < childPrefs.length; ++i) {
  614.         var type = childPrefs[i];
  615.         var uri = autoBranch.getCharPref(type);
  616.         if (uri) {
  617.           var handler = this.getWebContentHandlerByURI(type, uri);
  618.           this._setAutoHandler(type, handler);
  619.         }
  620.       }
  621.     }
  622.     catch (e) {
  623.       // No auto branch yet, that's fine
  624.       //LOG("WCCR.init: There is no auto branch, benign");
  625.     }
  626.   },
  627.  
  628.   /**
  629.    * See nsIObserver
  630.    */
  631.   observe: function WCCR_observe(subject, topic, data) {
  632.     var os = 
  633.         Cc["@mozilla.org/observer-service;1"].
  634.         getService(Ci.nsIObserverService);
  635.     switch (topic) {
  636.     case "app-startup":
  637.       os.addObserver(this, "profile-after-change", false);
  638.       break;
  639.     case "profile-after-change":
  640.       os.removeObserver(this, "profile-after-change");
  641.       this._init();
  642.       break;      
  643.     }
  644.   },
  645.  
  646.   /**
  647.    * See nsIFactory
  648.    */
  649.   createInstance: function WCCR_createInstance(outer, iid) {
  650.     if (outer != null)
  651.       throw Cr.NS_ERROR_NO_AGGREGATION;
  652.     return this.QueryInterface(iid);
  653.   },
  654.  
  655.   /**
  656.    * See nsIClassInfo
  657.    */
  658.   getInterfaces: function WCCR_getInterfaces(countRef) {
  659.     var interfaces = 
  660.         [Ci.nsIWebContentConverterService, Ci.nsIWebContentHandlerRegistrar,
  661.          Ci.nsIObserver, Ci.nsIClassInfo, Ci.nsIFactory, Ci.nsISupports];
  662.     countRef.value = interfaces.length;
  663.     return interfaces;
  664.   },
  665.   getHelperForLanguage: function WCCR_getHelperForLanguage(language) {
  666.     return null;
  667.   },
  668.   contractID: WCCR_CONTRACTID,
  669.   classDescription: WCCR_CLASSNAME,
  670.   classID: WCCR_CLASSID,
  671.   implementationLanguage: Ci.nsIProgrammingLanguage.JAVASCRIPT,
  672.   flags: Ci.nsIClassInfo.DOM_OBJECT,
  673.  
  674.   /**
  675.    * See nsISupports
  676.    */
  677.   QueryInterface: function WCCR_QueryInterface(iid) {
  678.     if (iid.equals(Ci.nsIWebContentConverterService) || 
  679.         iid.equals(Ci.nsIWebContentHandlerRegistrar) ||
  680.         iid.equals(Ci.nsIObserver) ||
  681.         iid.equals(Ci.nsIClassInfo) ||
  682.         iid.equals(Ci.nsIFactory) ||
  683.         iid.equals(Ci.nsISupports))
  684.       return this;
  685.     throw Cr.NS_ERROR_NO_INTERFACE;
  686.   },
  687. };
  688.  
  689. var Module = {
  690.   QueryInterface: function M_QueryInterface(iid) {
  691.     if (iid.equals(Ci.nsIModule) ||
  692.         iid.equals(Ci.nsISupports))
  693.       return this;
  694.     throw Cr.NS_ERROR_NO_INTERFACE;
  695.   },
  696.  
  697.   getClassObject: function M_getClassObject(cm, cid, iid) {
  698.     if (!iid.equals(Ci.nsIFactory))
  699.       throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  700.     
  701.     if (cid.equals(WCCR_CLASSID))
  702.       return WebContentConverterRegistrar;
  703.       
  704.     throw Cr.NS_ERROR_NO_INTERFACE;
  705.   },
  706.  
  707.   registerSelf: function M_registerSelf(cm, file, location, type) {
  708.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  709.     cr.registerFactoryLocation(WCCR_CLASSID, WCCR_CLASSNAME, WCCR_CONTRACTID,
  710.                                file, location, type);
  711.  
  712.     var catman = 
  713.         Cc["@mozilla.org/categorymanager;1"].getService(Ci.nsICategoryManager);
  714.     catman.addCategoryEntry("app-startup", WCCR_CLASSNAME, 
  715.                             "service," + WCCR_CONTRACTID, true, true);
  716.   },
  717.  
  718.   unregisterSelf: function M_unregisterSelf(cm, location, type) {
  719.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  720.     cr.unregisterFactoryLocation(WCCR_CLASSID, location);
  721.   },
  722.  
  723.   canUnload: function M_canUnload(cm) {
  724.     return true;
  725.   }
  726. };
  727.  
  728. function NSGetModule(cm, file) {
  729.   return Module;
  730. }
  731.  
  732. //@line 44 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/../../../../toolkit/content/debug.js"
  733.  
  734. var gTraceOnAssert = true;
  735.  
  736. /**
  737.  * This function provides a simple assertion function for JavaScript.
  738.  * If the condition is true, this function will do nothing.  If the
  739.  * condition is false, then the message will be printed to the console
  740.  * and an alert will appear showing a stack trace, so that the (alpha
  741.  * or nightly) user can file a bug containing it.  For future enhancements, 
  742.  * see bugs 330077 and 330078.
  743.  *
  744.  * To suppress the dialogs, you can run with the environment variable
  745.  * XUL_ASSERT_PROMPT set to 0 (if unset, this defaults to 1).
  746.  *
  747.  * @param condition represents the condition that we're asserting to be
  748.  *                  true when we call this function--should be
  749.  *                  something that can be evaluated as a boolean.
  750.  * @param message   a string to be displayed upon failure of the assertion
  751.  */
  752.  
  753. function NS_ASSERT(condition, message) {
  754.   if (condition)
  755.     return;
  756.  
  757.   var assertionText = "ASSERT: " + message + "\n";
  758.  
  759. //@line 72 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/../../../../toolkit/content/debug.js"
  760.   Components.util.reportError(assertionText);
  761.   return;
  762. //@line 108 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/../../../../toolkit/content/debug.js"
  763. }
  764.